//SPDX-FileCopyrightText: Copyright 2022-2024 深圳市同心圆网络有限公司
//SPDX-License-Identifier: GPL-3.0-only

package admin_appstore_api_serv

import (
	"context"

	"atomgit.com/openlinksaas-org/api-server/admin_api_serv/admin_common"
	"atomgit.com/openlinksaas-org/api-server/dao"
	"atomgit.com/openlinksaas-org/api-server/dao/appstore_dao"
	"atomgit.com/openlinksaas-org/proto-gen-go.git/appstore_api"
	"github.com/google/uuid"
	"go.mongodb.org/mongo-driver/mongo"
)

func (apiImpl *AppstoreAdminImpl) CreateMajorCate(ctx context.Context, req *appstore_api.AdminCreateMajorCateRequest) (*appstore_api.AdminCreateMajorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminCreateMajorCateResponse{
			Code:   appstore_api.AdminCreateMajorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminCreateMajorCateResponse{
			Code:   appstore_api.AdminCreateMajorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.AddCate {
		return &appstore_api.AdminCreateMajorCateResponse{
			Code:   appstore_api.AdminCreateMajorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	cateId := uuid.NewString()
	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Insert(sessCtx, &appstore_dao.CateDbItem{
			CateId:       cateId,
			CateName:     req.CateName,
			ParentCateId: "",
			Level:        appstore_dao.CATE_LEVEL_MAJOR,
			ChildCount:   0,
		})
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminCreateMajorCateResponse{
			Code:        appstore_api.AdminCreateMajorCateResponse_CODE_OK,
			MajorCateId: cateId,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminCreateMajorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) UpdateMajorCate(ctx context.Context, req *appstore_api.AdminUpdateMajorCateRequest) (*appstore_api.AdminUpdateMajorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminUpdateMajorCateResponse{
			Code:   appstore_api.AdminUpdateMajorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminUpdateMajorCateResponse{
			Code:   appstore_api.AdminUpdateMajorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.UpdateCate {
		return &appstore_api.AdminUpdateMajorCateResponse{
			Code:   appstore_api.AdminUpdateMajorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	exist, err := appstore_dao.CateDao.Exist(ctx, req.CateId, appstore_dao.CATE_LEVEL_MAJOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminUpdateMajorCateResponse{
			Code:   appstore_api.AdminUpdateMajorCateResponse_CODE_NO_MAJOR_CATE,
			ErrMsg: "分类不存在",
		}, nil
	}

	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.UpdateName(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_MAJOR, req.CateName)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminUpdateMajorCateResponse{
			Code: appstore_api.AdminUpdateMajorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminUpdateMajorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) RemoveMajorCate(ctx context.Context, req *appstore_api.AdminRemoveMajorCateRequest) (*appstore_api.AdminRemoveMajorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.RemoveCate {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	exist, err := appstore_dao.CateDao.Exist(ctx, req.CateId, appstore_dao.CATE_LEVEL_MAJOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_NO_MAJOR_CATE,
			ErrMsg: "分类不存在",
		}, nil
	}

	//检查是否还有下属二级分类
	count, err := appstore_dao.CateDao.Count(ctx, req.CateId, appstore_dao.CATE_LEVEL_MINOR)
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_HAS_CHILD_CATE,
			ErrMsg: "存在子分类",
		}, nil
	}
	//检查是否有应用关联
	count, err = appstore_dao.AppDao.Count(ctx, &appstore_api.ListAppParam{
		FilterByMajorCateId: true,
		MajorCateId:         req.CateId,
	})
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code:   appstore_api.AdminRemoveMajorCateResponse_CODE_HAS_APP,
			ErrMsg: "分类下存在应用",
		}, nil
	}

	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Remove(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_MAJOR)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminRemoveMajorCateResponse{
			Code: appstore_api.AdminRemoveMajorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminRemoveMajorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) CreateMinorCate(ctx context.Context, req *appstore_api.AdminCreateMinorCateRequest) (*appstore_api.AdminCreateMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminCreateMinorCateResponse{
			Code:   appstore_api.AdminCreateMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminCreateMinorCateResponse{
			Code:   appstore_api.AdminCreateMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.AddCate {
		return &appstore_api.AdminCreateMinorCateResponse{
			Code:   appstore_api.AdminCreateMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}
	//检查一级分类是否存在
	exist, err := appstore_dao.CateDao.Exist(ctx, req.MajorCateId, appstore_dao.CATE_LEVEL_MAJOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminCreateMinorCateResponse{
			Code:   appstore_api.AdminCreateMinorCateResponse_CODE_NO_MAJOR_CATE,
			ErrMsg: "一个分类不存在",
		}, nil
	}

	cateId := uuid.NewString()
	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Insert(sessCtx, &appstore_dao.CateDbItem{
			CateId:       cateId,
			CateName:     req.CateName,
			ParentCateId: req.MajorCateId,
			Level:        appstore_dao.CATE_LEVEL_MINOR,
		})
		if err != nil {
			return nil, err
		}
		count, err := appstore_dao.CateDao.Count(sessCtx, req.MajorCateId, appstore_dao.CATE_LEVEL_MINOR)
		if err != nil {
			return nil, err
		}
		err = appstore_dao.CateDao.UpdateChildCount(sessCtx, req.MajorCateId, appstore_dao.CATE_LEVEL_MAJOR, count)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminCreateMinorCateResponse{
			Code:   appstore_api.AdminCreateMinorCateResponse_CODE_OK,
			CateId: cateId,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminCreateMinorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) UpdateMinorCate(ctx context.Context, req *appstore_api.AdminUpdateMinorCateRequest) (*appstore_api.AdminUpdateMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminUpdateMinorCateResponse{
			Code:   appstore_api.AdminUpdateMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminUpdateMinorCateResponse{
			Code:   appstore_api.AdminUpdateMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.UpdateCate {
		return &appstore_api.AdminUpdateMinorCateResponse{
			Code:   appstore_api.AdminUpdateMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	exist, err := appstore_dao.CateDao.Exist(ctx, req.CateId, appstore_dao.CATE_LEVEL_MINOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminUpdateMinorCateResponse{
			Code:   appstore_api.AdminUpdateMinorCateResponse_CODE_NO_MINOR_CATE,
			ErrMsg: "二级分类不存在",
		}, nil
	}
	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.UpdateName(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_MINOR, req.CateName)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminUpdateMinorCateResponse{
			Code: appstore_api.AdminUpdateMinorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminUpdateMinorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) RemoveMinorCate(ctx context.Context, req *appstore_api.AdminRemoveMinorCateRequest) (*appstore_api.AdminRemoveMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.RemoveCate {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	cateItem, err := appstore_dao.CateDao.Get(ctx, req.CateId, appstore_dao.CATE_LEVEL_MINOR)
	if err != nil {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_NO_MINOR_CATE,
			ErrMsg: "二级分类不存在",
		}, nil
	}

	//检查是否有下属三级分类
	count, err := appstore_dao.CateDao.Count(ctx, req.CateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_HAS_CHILD_CATE,
			ErrMsg: "存在子分类",
		}, nil
	}
	//检查是否有应用关联
	count, err = appstore_dao.AppDao.Count(ctx, &appstore_api.ListAppParam{
		FilterByMinorCateId: true,
		MinorCateId:         req.CateId,
	})
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code:   appstore_api.AdminRemoveMinorCateResponse_CODE_HAS_APP,
			ErrMsg: "分类下存在应用",
		}, nil
	}

	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Remove(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_MINOR)
		if err != nil {
			return nil, err
		}
		count, err = appstore_dao.CateDao.Count(sessCtx, cateItem.ParentCateId, appstore_dao.CATE_LEVEL_MINOR)
		if err != nil {
			return nil, err
		}
		err = appstore_dao.CateDao.UpdateChildCount(sessCtx, cateItem.ParentCateId, appstore_dao.CATE_LEVEL_MAJOR, count)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminRemoveMinorCateResponse{
			Code: appstore_api.AdminRemoveMinorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminRemoveMinorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) CreateSubMinorCate(ctx context.Context, req *appstore_api.AdminCreateSubMinorCateRequest) (*appstore_api.AdminCreateSubMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminCreateSubMinorCateResponse{
			Code:   appstore_api.AdminCreateSubMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminCreateSubMinorCateResponse{
			Code:   appstore_api.AdminCreateSubMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.AddCate {
		return &appstore_api.AdminCreateSubMinorCateResponse{
			Code:   appstore_api.AdminCreateSubMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	exist, err := appstore_dao.CateDao.Exist(ctx, req.MinorCateId, appstore_dao.CATE_LEVEL_MINOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminCreateSubMinorCateResponse{
			Code:   appstore_api.AdminCreateSubMinorCateResponse_CODE_NO_MINOR_CATE,
			ErrMsg: "二级分类不存在",
		}, nil
	}

	cateId := uuid.NewString()
	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Insert(sessCtx, &appstore_dao.CateDbItem{
			CateId:       cateId,
			CateName:     req.CateName,
			ParentCateId: req.MinorCateId,
			Level:        appstore_dao.CATE_LEVEL_SUB_MINOR,
		})
		if err != nil {
			return nil, err
		}
		count, err := appstore_dao.CateDao.Count(sessCtx, req.MinorCateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
		if err != nil {
			return nil, err
		}
		err = appstore_dao.CateDao.UpdateChildCount(sessCtx, req.MinorCateId, appstore_dao.CATE_LEVEL_MINOR, count)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminCreateSubMinorCateResponse{
			Code:   appstore_api.AdminCreateSubMinorCateResponse_CODE_OK,
			CateId: cateId,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminCreateSubMinorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) UpdateSubMinorCate(ctx context.Context, req *appstore_api.AdminUpdateSubMinorCateRequest) (*appstore_api.AdminUpdateSubMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminUpdateSubMinorCateResponse{
			Code:   appstore_api.AdminUpdateSubMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminUpdateSubMinorCateResponse{
			Code:   appstore_api.AdminUpdateSubMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.UpdateCate {
		return &appstore_api.AdminUpdateSubMinorCateResponse{
			Code:   appstore_api.AdminUpdateSubMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	exist, err := appstore_dao.CateDao.Exist(ctx, req.CateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
	if err != nil {
		return nil, err
	}
	if !exist {
		return &appstore_api.AdminUpdateSubMinorCateResponse{
			Code:   appstore_api.AdminUpdateSubMinorCateResponse_CODE_NO_SUB_MINOR_CATE,
			ErrMsg: "三级分类不存在",
		}, nil
	}

	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.UpdateName(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_SUB_MINOR, req.CateName)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminUpdateSubMinorCateResponse{
			Code: appstore_api.AdminUpdateSubMinorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminUpdateSubMinorCateResponse), nil
}

func (apiImpl *AppstoreAdminImpl) RemoveSubMinorCate(ctx context.Context, req *appstore_api.AdminRemoveSubMinorCateRequest) (*appstore_api.AdminRemoveSubMinorCateResponse, error) {
	sess, ok := dao.CacheDao.GetAdminSession(ctx, req.AdminSessionId)
	if !ok {
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code:   appstore_api.AdminRemoveSubMinorCateResponse_CODE_WRONG_SESSION,
			ErrMsg: "会话不存在",
		}, nil
	}
	if !sess.AuthOk {
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code:   appstore_api.AdminRemoveSubMinorCateResponse_CODE_NOT_AUTH,
			ErrMsg: "未授权会话",
		}, nil
	}
	adminUserCfg, err := admin_common.GetAdminUserConfig(ctx, apiImpl.adminCfg, sess.UserName)
	if err != nil {
		return nil, err
	}
	if !adminUserCfg.PermInfo.AppStorePerm.RemoveCate {
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code:   appstore_api.AdminRemoveSubMinorCateResponse_CODE_NO_PERMISSION,
			ErrMsg: "没有权限",
		}, nil
	}

	cateItem, err := appstore_dao.CateDao.Get(ctx, req.CateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
	if err != nil {
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code:   appstore_api.AdminRemoveSubMinorCateResponse_CODE_NO_SUB_MINOR_CATE,
			ErrMsg: "三级分类不存在",
		}, nil
	}
	//检查是否有应用关联
	count, err := appstore_dao.AppDao.Count(ctx, &appstore_api.ListAppParam{
		FilterBySubMinorCateId: true,
		SubMinorCateId:         req.CateId,
	})
	if err != nil {
		return nil, err
	}
	if count > 0 {
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code:   appstore_api.AdminRemoveSubMinorCateResponse_CODE_HAS_APP,
			ErrMsg: "分类下存在应用",
		}, nil
	}

	dbSess, err := dao.StartSession()
	if err != nil {
		return nil, err
	}
	defer dao.EndSession(dbSess)

	ret, err := dbSess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
		err = appstore_dao.CateDao.Remove(sessCtx, req.CateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
		if err != nil {
			return nil, err
		}
		count, err = appstore_dao.CateDao.Count(sessCtx, cateItem.ParentCateId, appstore_dao.CATE_LEVEL_SUB_MINOR)
		if err != nil {
			return nil, err
		}
		err = appstore_dao.CateDao.UpdateChildCount(sessCtx, cateItem.ParentCateId, appstore_dao.CATE_LEVEL_MINOR, count)
		if err != nil {
			return nil, err
		}
		return &appstore_api.AdminRemoveSubMinorCateResponse{
			Code: appstore_api.AdminRemoveSubMinorCateResponse_CODE_OK,
		}, nil
	})
	if err != nil {
		return nil, err
	}
	return ret.(*appstore_api.AdminRemoveSubMinorCateResponse), nil
}
